/**
 * 数据库服务层
 * 提供所有数据表的CRUD操作和业务逻辑
 */

import { 
  supabase, 
  TABLES, 
  User, 
  BabyProfile, 
  ChatSession, 
  Message, 
  Content, 
  GrowthRecord 
} from '@/config/supabase';

// 通用查询参数接口
interface QueryParams {
  page?: number;
  pageSize?: number;
  sortBy?: string;
  sortOrder?: 'asc' | 'desc';
  filters?: Record<string, any>;
}

// 通用响应接口
interface QueryResponse<T> {
  data: T[];
  total: number;
  page: number;
  pageSize: number;
  hasMore: boolean;
}

/**
 * 用户数据服务
 */
export class UserService {
  /**
   * 创建或更新用户信息
   * @param userData 用户数据
   * @returns Promise<User | null>
   */
  static async upsertUser(userData: Partial<User>): Promise<User | null> {
    try {
      const { data, error } = await supabase
        .from(TABLES.USERS)
        .upsert(userData, { onConflict: 'phone' })
        .select()
        .single();
      
      if (error) {
        throw error;
      }
      
      return data;
    } catch (error) {
      console.error('创建/更新用户失败:', error);
      return null;
    }
  }
  
  /**
   * 根据ID获取用户信息
   * @param userId 用户ID
   * @returns Promise<User | null>
   */
  static async getUserById(userId: string): Promise<User | null> {
    try {
      const { data, error } = await supabase
        .from(TABLES.USERS)
        .select('*')
        .eq('id', userId)
        .single();
      
      if (error) {
        throw error;
      }
      
      return data;
    } catch (error) {
      console.error('获取用户信息失败:', error);
      return null;
    }
  }
  
  /**
   * 更新用户信息
   * @param userId 用户ID
   * @param updates 更新数据
   * @returns Promise<User | null>
   */
  static async updateUser(userId: string, updates: Partial<User>): Promise<User | null> {
    try {
      const { data, error } = await supabase
        .from(TABLES.USERS)
        .update({ ...updates, updated_at: new Date().toISOString() })
        .eq('id', userId)
        .select()
        .single();
      
      if (error) {
        throw error;
      }
      
      return data;
    } catch (error) {
      console.error('更新用户信息失败:', error);
      return null;
    }
  }
  
  /**
   * 删除用户
   * @param userId 用户ID
   * @returns Promise<boolean>
   */
  static async deleteUser(userId: string): Promise<boolean> {
    try {
      const { error } = await supabase
        .from(TABLES.USERS)
        .delete()
        .eq('id', userId);
      
      if (error) {
        throw error;
      }
      
      return true;
    } catch (error) {
      console.error('删除用户失败:', error);
      return false;
    }
  }
}

/**
 * 宝宝档案数据服务
 */
export class BabyProfileService {
  /**
   * 创建宝宝档案
   * @param babyData 宝宝数据
   * @returns Promise<BabyProfile | null>
   */
  static async createBaby(babyData: Omit<BabyProfile, 'id' | 'created_at'>): Promise<BabyProfile | null> {
    try {
      const { data, error } = await supabase
        .from(TABLES.BABY_PROFILES)
        .insert(babyData)
        .select()
        .single();
      
      if (error) {
        throw error;
      }
      
      return data;
    } catch (error) {
      console.error('创建宝宝档案失败:', error);
      return null;
    }
  }
  
  /**
   * 获取用户的宝宝列表
   * @param userId 用户ID
   * @returns Promise<BabyProfile[]>
   */
  static async getBabiesByUserId(userId: string): Promise<BabyProfile[]> {
    try {
      const { data, error } = await supabase
        .from(TABLES.BABY_PROFILES)
        .select('*')
        .eq('user_id', userId)
        .order('created_at', { ascending: false });
      
      if (error) {
        throw error;
      }
      
      return data || [];
    } catch (error) {
      console.error('获取宝宝列表失败:', error);
      return [];
    }
  }
  
  /**
   * 根据ID获取宝宝信息
   * @param babyId 宝宝ID
   * @returns Promise<BabyProfile | null>
   */
  static async getBabyById(babyId: string): Promise<BabyProfile | null> {
    try {
      const { data, error } = await supabase
        .from(TABLES.BABY_PROFILES)
        .select('*')
        .eq('id', babyId)
        .single();
      
      if (error) {
        throw error;
      }
      
      return data;
    } catch (error) {
      console.error('获取宝宝信息失败:', error);
      return null;
    }
  }
  
  /**
   * 更新宝宝信息
   * @param babyId 宝宝ID
   * @param updates 更新数据
   * @returns Promise<BabyProfile | null>
   */
  static async updateBaby(babyId: string, updates: Partial<BabyProfile>): Promise<BabyProfile | null> {
    try {
      const { data, error } = await supabase
        .from(TABLES.BABY_PROFILES)
        .update(updates)
        .eq('id', babyId)
        .select()
        .single();
      
      if (error) {
        throw error;
      }
      
      return data;
    } catch (error) {
      console.error('更新宝宝信息失败:', error);
      return null;
    }
  }
  
  /**
   * 删除宝宝档案
   * @param babyId 宝宝ID
   * @returns Promise<boolean>
   */
  static async deleteBaby(babyId: string): Promise<boolean> {
    try {
      const { error } = await supabase
        .from(TABLES.BABY_PROFILES)
        .delete()
        .eq('id', babyId);
      
      if (error) {
        throw error;
      }
      
      return true;
    } catch (error) {
      console.error('删除宝宝档案失败:', error);
      return false;
    }
  }
}

/**
 * 聊天会话数据服务
 */
export class ChatSessionService {
  /**
   * 创建聊天会话
   * @param sessionData 会话数据
   * @returns Promise<ChatSession | null>
   */
  static async createSession(sessionData: Omit<ChatSession, 'id' | 'created_at' | 'updated_at'>): Promise<ChatSession | null> {
    try {
      const { data, error } = await supabase
        .from(TABLES.CHAT_SESSIONS)
        .insert(sessionData)
        .select()
        .single();
      
      if (error) {
        throw error;
      }
      
      return data;
    } catch (error) {
      console.error('创建聊天会话失败:', error);
      return null;
    }
  }
  
  /**
   * 获取用户的聊天会话列表
   * @param userId 用户ID
   * @param params 查询参数
   * @returns Promise<QueryResponse<ChatSession>>
   */
  static async getSessionsByUserId(
    userId: string, 
    params: QueryParams = {}
  ): Promise<QueryResponse<ChatSession>> {
    try {
      const { page = 1, pageSize = 20, sortBy = 'updated_at', sortOrder = 'desc' } = params;
      const offset = (page - 1) * pageSize;
      
      // 获取总数
      const { count } = await supabase
        .from(TABLES.CHAT_SESSIONS)
        .select('*', { count: 'exact', head: true })
        .eq('user_id', userId);
      
      // 获取数据
      const { data, error } = await supabase
        .from(TABLES.CHAT_SESSIONS)
        .select('*')
        .eq('user_id', userId)
        .order(sortBy, { ascending: sortOrder === 'asc' })
        .range(offset, offset + pageSize - 1);
      
      if (error) {
        throw error;
      }
      
      return {
        data: data || [],
        total: count || 0,
        page,
        pageSize,
        hasMore: (count || 0) > offset + pageSize
      };
    } catch (error) {
      console.error('获取聊天会话列表失败:', error);
      return {
        data: [],
        total: 0,
        page: 1,
        pageSize: 20,
        hasMore: false
      };
    }
  }
  
  /**
   * 更新聊天会话
   * @param sessionId 会话ID
   * @param updates 更新数据
   * @returns Promise<ChatSession | null>
   */
  static async updateSession(sessionId: string, updates: Partial<ChatSession>): Promise<ChatSession | null> {
    try {
      const { data, error } = await supabase
        .from(TABLES.CHAT_SESSIONS)
        .update({ ...updates, updated_at: new Date().toISOString() })
        .eq('id', sessionId)
        .select()
        .single();
      
      if (error) {
        throw error;
      }
      
      return data;
    } catch (error) {
      console.error('更新聊天会话失败:', error);
      return null;
    }
  }
  
  /**
   * 删除聊天会话
   * @param sessionId 会话ID
   * @returns Promise<boolean>
   */
  static async deleteSession(sessionId: string): Promise<boolean> {
    try {
      const { error } = await supabase
        .from(TABLES.CHAT_SESSIONS)
        .delete()
        .eq('id', sessionId);
      
      if (error) {
        throw error;
      }
      
      return true;
    } catch (error) {
      console.error('删除聊天会话失败:', error);
      return false;
    }
  }
}

/**
 * 消息数据服务
 */
export class MessageService {
  /**
   * 创建消息
   * @param messageData 消息数据
   * @returns Promise<Message | null>
   */
  static async createMessage(messageData: Omit<Message, 'id' | 'created_at'>): Promise<Message | null> {
    try {
      const { data, error } = await supabase
        .from(TABLES.MESSAGES)
        .insert(messageData)
        .select()
        .single();
      
      if (error) {
        throw error;
      }
      
      return data;
    } catch (error) {
      console.error('创建消息失败:', error);
      return null;
    }
  }
  
  /**
   * 获取会话的消息列表
   * @param sessionId 会话ID
   * @param params 查询参数
   * @returns Promise<QueryResponse<Message>>
   */
  static async getMessagesBySessionId(
    sessionId: string, 
    params: QueryParams = {}
  ): Promise<QueryResponse<Message>> {
    try {
      const { page = 1, pageSize = 50, sortBy = 'created_at', sortOrder = 'asc' } = params;
      const offset = (page - 1) * pageSize;
      
      // 获取总数
      const { count } = await supabase
        .from(TABLES.MESSAGES)
        .select('*', { count: 'exact', head: true })
        .eq('session_id', sessionId);
      
      // 获取数据
      const { data, error } = await supabase
        .from(TABLES.MESSAGES)
        .select('*')
        .eq('session_id', sessionId)
        .order(sortBy, { ascending: sortOrder === 'asc' })
        .range(offset, offset + pageSize - 1);
      
      if (error) {
        throw error;
      }
      
      return {
        data: data || [],
        total: count || 0,
        page,
        pageSize,
        hasMore: (count || 0) > offset + pageSize
      };
    } catch (error) {
      console.error('获取消息列表失败:', error);
      return {
        data: [],
        total: 0,
        page: 1,
        pageSize: 50,
        hasMore: false
      };
    }
  }
  
  /**
   * 更新消息
   * @param messageId 消息ID
   * @param updates 更新数据
   * @returns Promise<Message | null>
   */
  static async updateMessage(messageId: string, updates: Partial<Message>): Promise<Message | null> {
    try {
      const { data, error } = await supabase
        .from(TABLES.MESSAGES)
        .update(updates)
        .eq('id', messageId)
        .select()
        .single();
      
      if (error) {
        throw error;
      }
      
      return data;
    } catch (error) {
      console.error('更新消息失败:', error);
      return null;
    }
  }
  
  /**
   * 删除消息
   * @param messageId 消息ID
   * @returns Promise<boolean>
   */
  static async deleteMessage(messageId: string): Promise<boolean> {
    try {
      const { error } = await supabase
        .from(TABLES.MESSAGES)
        .delete()
        .eq('id', messageId);
      
      if (error) {
        throw error;
      }
      
      return true;
    } catch (error) {
      console.error('删除消息失败:', error);
      return false;
    }
  }
}

/**
 * 内容数据服务
 */
export class ContentService {
  /**
   * 创建内容
   * @param contentData 内容数据
   * @returns Promise<Content | null>
   */
  static async createContent(contentData: Omit<Content, 'id' | 'created_at' | 'view_count' | 'like_count'>): Promise<Content | null> {
    try {
      const { data, error } = await supabase
        .from(TABLES.CONTENTS)
        .insert({ ...contentData, view_count: 0, like_count: 0 })
        .select()
        .single();
      
      if (error) {
        throw error;
      }
      
      return data;
    } catch (error) {
      console.error('创建内容失败:', error);
      return null;
    }
  }
  
  /**
   * 获取内容列表
   * @param params 查询参数
   * @returns Promise<QueryResponse<Content>>
   */
  static async getContents(params: QueryParams = {}): Promise<QueryResponse<Content>> {
    try {
      const { page = 1, pageSize = 20, sortBy = 'created_at', sortOrder = 'desc', filters = {} } = params;
      const offset = (page - 1) * pageSize;
      
      let query = supabase.from(TABLES.CONTENTS).select('*', { count: 'exact' });
      
      // 应用过滤条件
      Object.entries(filters).forEach(([key, value]) => {
        if (value !== undefined && value !== null) {
          query = query.eq(key, value);
        }
      });
      
      // 只显示已发布的内容
      query = query.eq('status', 'published');
      
      // 获取总数
      const { count } = await query;
      
      // 获取数据
      const { data, error } = await query
        .order(sortBy, { ascending: sortOrder === 'asc' })
        .range(offset, offset + pageSize - 1);
      
      if (error) {
        throw error;
      }
      
      return {
        data: data || [],
        total: count || 0,
        page,
        pageSize,
        hasMore: (count || 0) > offset + pageSize
      };
    } catch (error) {
      console.error('获取内容列表失败:', error);
      return {
        data: [],
        total: 0,
        page: 1,
        pageSize: 20,
        hasMore: false
      };
    }
  }
  
  /**
   * 根据ID获取内容
   * @param contentId 内容ID
   * @returns Promise<Content | null>
   */
  static async getContentById(contentId: string): Promise<Content | null> {
    try {
      const { data, error } = await supabase
        .from(TABLES.CONTENTS)
        .select('*')
        .eq('id', contentId)
        .single();
      
      if (error) {
        throw error;
      }
      
      return data;
    } catch (error) {
      console.error('获取内容详情失败:', error);
      return null;
    }
  }
  
  /**
   * 更新内容
   * @param contentId 内容ID
   * @param updates 更新数据
   * @returns Promise<Content | null>
   */
  static async updateContent(contentId: string, updates: Partial<Content>): Promise<Content | null> {
    try {
      const { data, error } = await supabase
        .from(TABLES.CONTENTS)
        .update(updates)
        .eq('id', contentId)
        .select()
        .single();
      
      if (error) {
        throw error;
      }
      
      return data;
    } catch (error) {
      console.error('更新内容失败:', error);
      return null;
    }
  }
  
  /**
   * 增加内容浏览量
   * @param contentId 内容ID
   * @returns Promise<boolean>
   */
  static async incrementViewCount(contentId: string): Promise<boolean> {
    try {
      const { error } = await supabase.rpc('increment_view_count', {
        content_id: contentId
      });
      
      if (error) {
        throw error;
      }
      
      return true;
    } catch (error) {
      console.error('增加浏览量失败:', error);
      return false;
    }
  }
  
  /**
   * 删除内容
   * @param contentId 内容ID
   * @returns Promise<boolean>
   */
  static async deleteContent(contentId: string): Promise<boolean> {
    try {
      const { error } = await supabase
        .from(TABLES.CONTENTS)
        .delete()
        .eq('id', contentId);
      
      if (error) {
        throw error;
      }
      
      return true;
    } catch (error) {
      console.error('删除内容失败:', error);
      return false;
    }
  }
}

/**
 * 成长记录数据服务
 */
export class GrowthRecordService {
  /**
   * 创建成长记录
   * @param recordData 记录数据
   * @returns Promise<GrowthRecord | null>
   */
  static async createRecord(recordData: Omit<GrowthRecord, 'id' | 'created_at'>): Promise<GrowthRecord | null> {
    try {
      const { data, error } = await supabase
        .from(TABLES.GROWTH_RECORDS)
        .insert(recordData)
        .select()
        .single();
      
      if (error) {
        throw error;
      }
      
      return data;
    } catch (error) {
      console.error('创建成长记录失败:', error);
      return null;
    }
  }
  
  /**
   * 获取宝宝的成长记录
   * @param babyId 宝宝ID
   * @returns Promise<GrowthRecord[]>
   */
  static async getRecordsByBabyId(babyId: string): Promise<GrowthRecord[]> {
    try {
      const { data, error } = await supabase
        .from(TABLES.GROWTH_RECORDS)
        .select('*')
        .eq('baby_id', babyId)
        .order('date', { ascending: false });
      
      if (error) {
        throw error;
      }
      
      return data || [];
    } catch (error) {
      console.error('获取成长记录失败:', error);
      return [];
    }
  }
  
  /**
   * 更新成长记录
   * @param recordId 记录ID
   * @param updates 更新数据
   * @returns Promise<GrowthRecord | null>
   */
  static async updateRecord(recordId: string, updates: Partial<GrowthRecord>): Promise<GrowthRecord | null> {
    try {
      const { data, error } = await supabase
        .from(TABLES.GROWTH_RECORDS)
        .update(updates)
        .eq('id', recordId)
        .select()
        .single();
      
      if (error) {
        throw error;
      }
      
      return data;
    } catch (error) {
      console.error('更新成长记录失败:', error);
      return null;
    }
  }
  
  /**
   * 删除成长记录
   * @param recordId 记录ID
   * @returns Promise<boolean>
   */
  static async deleteRecord(recordId: string): Promise<boolean> {
    try {
      const { error } = await supabase
        .from(TABLES.GROWTH_RECORDS)
        .delete()
        .eq('id', recordId);
      
      if (error) {
        throw error;
      }
      
      return true;
    } catch (error) {
      console.error('删除成长记录失败:', error);
      return false;
    }
  }
}

// 导出所有服务
export default {
  UserService,
  BabyProfileService,
  ChatSessionService,
  MessageService,
  ContentService,
  GrowthRecordService
};